package com.lianqi.emcpframework.utils;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;

/**
 * @program emcp-framework
 * @ClassName StringUtils
 * @description: 字符串工具类
 * @author: sky
 * @create: 2018/11/13 13:46
 */
public class StringUtils {

    static final char CN_CHAR_START = '\u4e00';
    static final char CN_CHAR_END = '\u9fa5';

    static final Map<String,Pattern> PATTERN_CACHE = new ConcurrentHashMap<>();

    /**
     * 编译正则表达式并缓存
     * @param regex 表达式
     * @return pattern 对象
     */
    public static final Pattern compileRegex(String regex){
        Pattern pattern = PATTERN_CACHE.get(regex);
        if (pattern == null){
            pattern = Pattern.compile(regex);
            PATTERN_CACHE.put(regex,pattern);
        }
        return pattern;
    }
    /**
     * 判断字符串中是否包含中文
     * @param string
     * @return
     */
    public static boolean containsChineseChar(String string){
        char[] chars = string.toCharArray();
        for (int i = 0; i < chars.length; i ++){
            if (chars[i] >= CN_CHAR_START && chars[i] <= CN_CHAR_END){
                return true;
            }
        }
        return false;
    }

    /**
     * 判断对象是否为null或者为空
     * @param obj  对象
     * @return true/false
     */
    public static boolean isNullOrEmpty(Object obj){
        return obj == null || "".equals(obj.toString());
    }

    /**
     * 判断对象是否为int数字
     * @param object 对象
     * @return true/false
     */
    public static boolean isInt(Object object){
        if (isNullOrEmpty(object)){
            return  false;
        }
        if (object instanceof Integer){
            return true;
        }
        return compileRegex("[-+]?\\d+").matcher(object.toString()).matches();

    }

    /**
     * 判断对象是否为double类型
     * @param object 对象
     * @return true/false
     */
    public static boolean isDouble(Object object){
        if (isNullOrEmpty(object)){
            return false;
        }

        if (object instanceof Double || object instanceof Float){
            return true;
        }

        return compileRegex("[-+]?\\d+\\.\\d+").matcher(object.toString()).matches();
    }

    /**
     * 判断对象是否为boolean
     * @param object 对象
     * @return true/false
     */
    public static boolean isBoolean(Object object){
        if (object instanceof Boolean){
            return true;
        }

        String value = String.valueOf(object);
        return "true".equalsIgnoreCase(value) || "false".equalsIgnoreCase(value);
    }
    /**
     * 对象转int 如果无法转换 返回指定默认值
     * @param obj  对象
     * @param value 默认值
     * @return  int
     */
    public static int toInt(Object obj,int value){
        if (obj instanceof Number){
            return ((Number)obj).intValue();
        }

        if (isInt(obj)){
            return Integer.parseInt(obj.toString());
        }
        if (isDouble(obj)){
            return (int) Double.parseDouble(obj.toString());
        }
        return value;
    }

    /**
     * 对象转int 如果无法转换 返回默认值0
     * @param object 对象
     * @return int
     */
    public static int toInt(Object object){
        return toInt(object,0);
    }

    /**
     * 对象转long 如果无法转换 返回指定默认值
     * @param obj 对象
     * @param value 指定的默认值
     * @return long
     */
    public static long toLong(Object obj,long value){
        if (obj instanceof Number){
            return ((Number)obj).longValue();
        }
        if (isDouble(obj)){
            return (long) Double.parseDouble(obj.toString());
        }
        if (isInt(obj)){
            return Long.parseLong(obj.toString());
        }
        return value;
    }

    /**
     * 对象转long 如果无法转换 返回默认值0
     * @param object 对象
     * @return long
     */
    public static long toLong(Object object){
        return toLong(object,0);
    }

    /**
     * 对象是否为true
     * @param object 对象
     * @return
     */
    public static boolean isTrue(Object object){
        return "true".equalsIgnoreCase(object.toString());
    }
}
